Changeset 65401 in vbox for trunk/src/VBox

Timestamp:

Jan 23, 2017 1:33:45 PM (8 years ago)

Author:

vboxsync

Message:

VideoRec: Update.

Location:

trunk/src/VBox/Main

Files:

• include/DisplayImpl.h (modified) (1 diff)
• src-client/DisplayImpl.cpp (modified) (5 diffs)
• src-client/VideoRec.cpp (modified) (24 diffs)
• src-client/VideoRec.h (modified) (1 diff)

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

@@ -504 +504 @@
 
 #ifdef VBOX_WITH_VIDEOREC
-    VIDEORECCONTEXT *mpVideoRecCtx;
-    bool maVideoRecEnabled[SchemaDefs::MaxGuestMonitors];
+    VIDEORECCONTEXT     *mpVideoRecCtx;
+    bool                 maVideoRecEnabled[SchemaDefs::MaxGuestMonitors];
 #endif
 

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

@@ -2349 +2349 @@
         if (RT_SUCCESS(rc))
         {
-#ifndef DEUBG_andy
             if (mcMonitors > 1)
                 rc = RTStrAPrintf(&pszName, "%s-%u%s", pszAbsPath, uScreen+1, pszSuff);
             else
                 rc = RTStrAPrintf(&pszName, "%s%s", pszAbsPath, pszSuff);
-#else
-            if (mcMonitors > 1)
-                rc = RTStrAPrintf(&pszName, "/tmp/avcap-%u.webm", uScreen+1);
-            else
-                rc = RTStrAPrintf(&pszName, "/tmp/avcap.webm");
-#endif
         }
         if (RT_SUCCESS(rc))
@@ -2392 +2385 @@
         if (RT_SUCCESS(rc))
         {
-            LogRel(("Display::VideoCaptureStart: WebM/VP8 video recording screen #%u with %ux%u @ %u kbps, %u fps to '%s' "
-                    "enabled\n", uScreen, ulWidth, ulHeight, ulRate, ulFPS, pszName));
-
             videoCaptureScreenChanged(uScreen);
         }
         else
-            LogRel(("Display::VideoCaptureStart: Failed to initialize video recording context #%u (%Rrc)!\n", uScreen, rc));
+            LogRel(("Display::VideoCaptureStart: Failed to initialize video recording context #%u, (%Rrc)\n", uScreen, rc));
+
         RTStrFree(pszName);
         RTStrFree(pszSuff);
@@ -2415 +2406 @@
 {
 #ifdef VBOX_WITH_VIDEOREC
-    if (VideoRecIsEnabled(mpVideoRecCtx))
-        LogRel(("Display::VideoCaptureStop: WebM/VP8 video recording stopped\n"));
+    if (!VideoRecIsEnabled(mpVideoRecCtx))
+        return;
+
     VideoRecContextDestroy(mpVideoRecCtx);
     mpVideoRecCtx = NULL;
@@ -2429 +2421 @@
 void Display::videoCaptureScreenChanged(unsigned uScreenId)
 {
+    if (   !VideoRecIsEnabled(mpVideoRecCtx)
+        || !maVideoRecEnabled[uScreenId])
+    {
+        /* Skip recording this screen. */
+        return;
+    }
+
+    /* Get a new source bitmap which will be used by video capture code. */
     ComPtr<IDisplaySourceBitmap> pSourceBitmap;
-
-    if (VideoRecIsEnabled(mpVideoRecCtx) && maVideoRecEnabled[uScreenId])
-    {
-        /* Get a new source bitmap which will be used by video capture code. */
-        QuerySourceBitmap(uScreenId, pSourceBitmap.asOutParam());
-    }
-
-    int rc = RTCritSectEnter(&mVideoCaptureLock);
-    if (RT_SUCCESS(rc))
+    QuerySourceBitmap(uScreenId, pSourceBitmap.asOutParam());
+
+    int rc2 = RTCritSectEnter(&mVideoCaptureLock);
+    if (RT_SUCCESS(rc2))
     {
         maFramebuffers[uScreenId].videoCapture.pSourceBitmap = pSourceBitmap;
-        RTCritSectLeave(&mVideoCaptureLock);
+
+        rc2 = RTCritSectLeave(&mVideoCaptureLock);
+        AssertRC(rc2);
     }
 }
@@ -3186 +3183 @@
                     continue;
 
-                if (VideoRecIsFull(pDisplay->mpVideoRecCtx, uScreenId, u64Now))
+                if (VideoRecLimitReached(pDisplay->mpVideoRecCtx, uScreenId, u64Now))
                 {
                     pDisplay->i_VideoCaptureStop();

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

@@ -18 +18 @@
 #define LOG_GROUP LOG_GROUP_MAIN
 
+#include <stdexcept>
 #include <vector>
 
@@ -79 +80 @@
 
 /* Must be always accessible and therefore cannot be part of VIDEORECCONTEXT */
-static uint32_t g_enmState = VIDEORECSTS_UNINITIALIZED;
+static uint32_t g_enmState = VIDEORECSTS_UNINITIALIZED; /** @todo r=andy Make this part of VIDEORECCONTEXT + remove busy waiting. */
 
 /**
@@ -109 +110 @@
     /** Container context. */
     WebMWriter         *pEBML;
+    /** Track number of audio stream. */
+    uint8_t             uTrackAudio;
     /** Track number of video stream. */
     uint8_t             uTrackVideo;
     /** Codec data. */
     VIDEORECCODEC       Codec;
+    /** Screen ID. */
+    uint16_t            uScreen;
     /** Target X resolution (in pixels). */
     uint32_t            uTargetWidth;
@@ -135 +140 @@
     /** Minimal delay between two frames. */
     uint32_t            uDelay;
-    /** Time stamp of the last frame we encoded. */
-    uint64_t            u64LastTimeStamp;
-    /** Time stamp of the current frame. */
-    uint64_t            u64TimeStamp;
+    /** Time stamp (in ms) of the last frame we encoded. */
+    uint64_t            uLastTimeStampMs;
+    /** Time stamp (in ms) of the current frame. */
+    uint64_t            uCurTimeStampMs;
     /** Encoder deadline. */
     unsigned int        uEncoderDeadline;
@@ -159 +164 @@
     /** Worker thread. */
     RTTHREAD            Thread;
-    /** Maximal time stamp. */
-    uint64_t            u64MaxTimeStamp;
-    /** Maximal file size in MB. */
-    uint32_t            uMaxFileSize;
+    uint64_t            tsStartMs;
+    /** Maximal time (in ms) to record. */
+    uint64_t            uMaxTimeMs;
+    /** Maximal file size (in MB) to record. */
+    uint32_t            uMaxSizeMB;
     /** Vector of current video recording stream contexts. */
     VideoRecStreams     vecStreams;
@@ -440 +446 @@
     RT_NOREF(hThreadSelf);
     PVIDEORECCONTEXT pCtx = (PVIDEORECCONTEXT)pvUser;
+
     for (;;)
     {
@@ -509 +516 @@
         try
         {
+            pStream->uScreen = uScreen;
+
             pCtx->vecStreams.push_back(pStream);
 
@@ -610 +619 @@
                 pStream->pu8RgbBuf = NULL;
             }
+
+            LogRel(("VideoRec: Recording screen #%u stopped\n", pStream->uScreen));
         }
 
@@ -628 +639 @@
 
     ASMAtomicWriteU32(&g_enmState, VIDEORECSTS_UNINITIALIZED);
+}
+
+/**
+ * Retrieves a specific recording stream of a recording context.
+ *
+ * @returns Pointer to recording if found, or NULL if not found.
+ * @param                       Recording context to look up stream for.
+ * @param                       Screen number of recording stream to look up.
+ */
+DECLINLINE(PVIDEORECSTREAM) videoRecStreamGet(PVIDEORECCONTEXT pCtx, uint32_t uScreen)
+{
+    AssertPtrReturn(pCtx, NULL);
+
+    PVIDEORECSTREAM pStream;
+
+    try
+    {
+        pStream = pCtx->vecStreams.at(uScreen);
+    }
+    catch (std::out_of_range)
+    {
+        pStream = NULL;
+    }
+
+    return pStream;
 }
 
@@ -634 +670 @@
  *
  * @returns IPRT status code.
- * @param   pCtx                Pointer to video recording context to initialize Framebuffer width.
- * @param   uScreen             Screen number.
- * @param   pszFile             File to save the recorded data
- * @param   uWidth              Width of the target image in the video recoriding file (movie)
- * @param   uHeight             Height of the target image in video recording file.
- * @param   uRate               Rate.
- * @param   uFps                FPS.
- * @param   uMaxTime
- * @param   uMaxFileSize
- * @param   pszOptions
+ * @param   pCtx                Pointer to video recording context.
+ * @param   uScreen             Screen number to record.
+ * @param   pszFile             File to save recording to.
+ * @param   uWidth              Target video resolution (width).
+ * @param   uHeight             Target video resolution (height).
+ * @param   uRate               Target encoding bit rate.
+ * @param   uFps                Target FPS (Frame Per Second).
+ * @param   uMaxTimeS           Maximum time (in s) to record, or 0 for no time limit.
+ * @param   uMaxFileSizeMB      Maximum file size (in MB) to record, or 0 for no limit.
+ * @param   pszOptions          Additional options in "key=value" array format. Optional.
  */
 int VideoRecStreamInit(PVIDEORECCONTEXT pCtx, uint32_t uScreen, const char *pszFile,
-                       uint32_t uWidth, uint32_t uHeight, uint32_t uRate, uint32_t uFps,
-                       uint32_t uMaxTime, uint32_t uMaxFileSize, const char *pszOptions)
-{
-    AssertPtrReturn(pCtx,                           VERR_INVALID_PARAMETER);
-    AssertReturn(uScreen < pCtx->vecStreams.size(), VERR_INVALID_PARAMETER);
-
-    pCtx->u64MaxTimeStamp = (uMaxTime > 0 ? RTTimeProgramMilliTS() + uMaxTime * 1000 : 0);
-    pCtx->uMaxFileSize = uMaxFileSize;
-
-    PVIDEORECSTREAM pStream = pCtx->vecStreams.at(uScreen);
+                       uint32_t uWidth, uint32_t uHeight, uint32_t uRate, uint32_t uFPS,
+                       uint32_t uMaxTimeS, uint32_t uMaxSizeMB, const char *pszOptions)
+{
+    AssertPtrReturn(pCtx,    VERR_INVALID_POINTER);
+    AssertPtrReturn(pszFile, VERR_INVALID_POINTER);
+    AssertReturn(uWidth,     VERR_INVALID_PARAMETER);
+    AssertReturn(uHeight,    VERR_INVALID_PARAMETER);
+    AssertReturn(uRate,      VERR_INVALID_PARAMETER);
+    AssertReturn(uFPS,       VERR_INVALID_PARAMETER);
+    /* pszOptions is optional. */
+
+    PVIDEORECSTREAM pStream = videoRecStreamGet(pCtx, uScreen);
+    if (!pStream)
+        return VERR_NOT_FOUND;
+
+    pCtx->uMaxTimeMs = (uMaxTimeS > 0 ? RTTimeProgramMilliTS() + uMaxTimeS * 1000 : 0);
+    pCtx->uMaxSizeMB = uMaxSizeMB;
 
     pStream->uTargetWidth  = uWidth;
@@ -699 +742 @@
             else if (value.compare("good", Utf8Str::CaseInsensitive) == 0)
             {
-                pStream->uEncoderDeadline = 1000000 / uFps;
+                pStream->uEncoderDeadline = 1000000 / uFPS;
             }
             else if (value.compare("best", Utf8Str::CaseInsensitive) == 0)
@@ -752 +795 @@
     }
 
-    pStream->uDelay = 1000 / uFps;
+    pStream->uDelay = 1000 / uFPS;
 
     if (fHasVideoTrack)
     {
-        rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFps, &pStream->uTrackVideo);
+        rc = pStream->pEBML->AddVideoTrack(uWidth, uHeight, uFPS, &pStream->uTrackVideo);
         if (RT_FAILURE(rc))
         {
@@ -764 +807 @@
     }
 
+#ifdef VBOX_WITH_AUDIO_VIDEOREC
+    if (fHasAudioTrack)
+    {
+        rc = pStream->pEBML->AddAudioTrack(48000, 2, 16, &pStream->uTrackAudio);
+        if (RT_FAILURE(rc))
+        {
+            LogRel(("VideoRec: Failed to add audio track to output file '%s' (%Rrc)\n", pszFile, rc));
+            return rc;
+        }
+    }
+#endif
+
 #ifdef VBOX_WITH_LIBVPX
-    /* target bitrate in kilobits per second */
+    /* Target bitrate in kilobits per second. */
     pStream->Codec.VPX.Config.rc_target_bitrate = uRate;
-    /* frame width */
+    /* Frame width. */
     pStream->Codec.VPX.Config.g_w = uWidth;
-    /* frame height */
+    /* Frame height. */
     pStream->Codec.VPX.Config.g_h = uHeight;
-    /* 1ms per frame */
+    /* 1ms per frame. */
     pStream->Codec.VPX.Config.g_timebase.num = 1;
     pStream->Codec.VPX.Config.g_timebase.den = 1000;
-    /* disable multithreading */
+    /* Disable multithreading. */
     pStream->Codec.VPX.Config.g_threads = 0;
 
@@ -796 +851 @@
     pCtx->fEnabled = true;
     pStream->fEnabled = true;
+
+    LogRel(("VideoRec: Recording screen #%u with %ux%u @ %u kbps, %u fps to '%s' started\n",
+            uScreen, uWidth, uHeight, uRate, uFPS, pszFile));
 
     return VINF_SUCCESS;
@@ -821 +879 @@
  * @param   pCtx                Pointer to video recording context.
  * @param   uScreen             Screen ID.
- * @param   u64TimeStamp        Current time stamp.
- */
-bool VideoRecIsReady(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStamp)
+ * @param   u64TimeStampMs      Current time stamp (in ms).
+ */
+bool VideoRecIsReady(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStampMs)
 {
     uint32_t enmState = ASMAtomicReadU32(&g_enmState);
@@ -829 +887 @@
         return false;
 
-    PVIDEORECSTREAM pStream = pCtx->vecStreams.at(uScreen);
-    if (!pStream->fEnabled)
+    PVIDEORECSTREAM pStream = videoRecStreamGet(pCtx, uScreen);
+    if (   !pStream
+        || !pStream->fEnabled)
+    {
         return false;
-
-    if (u64TimeStamp < pStream->u64LastTimeStamp + pStream->uDelay)
+    }
+
+    if (u64TimeStampMs < pStream->uLastTimeStampMs + pStream->uDelay)
         return false;
 
@@ -843 +904 @@
 
 /**
- * VideoRec utility function to check if the file size has reached
- * specified limits (if any).
+ * VideoRec utility function to check if a specified limit for recording
+ * has been reached.
  *
  * @returns true if any limit has been reached.
  * @param   pCtx                Pointer to video recording context.
  * @param   uScreen             Screen ID.
- * @param   u64TimeStamp        Current time stamp.
- */
-
-bool VideoRecIsFull(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStamp)
-{
-    PVIDEORECSTREAM pStream = pCtx->vecStreams.at(uScreen);
-    if(!pStream->fEnabled)
+ * @param   tsNowMs             Current time stamp (in ms).
+ */
+
+bool VideoRecLimitReached(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t tsNowMs)
+{
+    PVIDEORECSTREAM pStream = videoRecStreamGet(pCtx, uScreen);
+    if (   !pStream
+        || !pStream->fEnabled)
+    {
         return false;
-
-    if(pCtx->u64MaxTimeStamp > 0 && u64TimeStamp >= pCtx->u64MaxTimeStamp)
+    }
+
+    if (   pCtx->uMaxTimeMs
+        && (tsNowMs - pCtx->tsStartMs) >= pCtx->uMaxTimeMs)
+    {
         return true;
-
-    if (pCtx->uMaxFileSize > 0)
+    }
+
+    if (pCtx->uMaxSizeMB)
     {
         uint64_t sizeInMB = pStream->pEBML->GetFileSize() / (1024 * 1024);
-        if(sizeInMB >= pCtx->uMaxFileSize)
+        if(sizeInMB >= pCtx->uMaxSizeMB)
             return true;
     }
@@ -890 +957 @@
 #ifdef VBOX_WITH_LIBVPX
     /* presentation time stamp */
-    vpx_codec_pts_t pts = pStream->u64TimeStamp;
+    vpx_codec_pts_t pts = pStream->uCurTimeStampMs;
     vpx_codec_err_t rcv = vpx_codec_encode(&pStream->Codec.VPX.CodecCtx,
                                            &pStream->Codec.VPX.RawImage,
@@ -921 +988 @@
 
             default:
-                LogFlow(("Unexpected CODEC packet kind %ld\n", pPacket->kind));
+                AssertFailed();
+                LogFunc(("Unexpected CODEC packet kind %ld\n", pPacket->kind));
                 break;
         }
@@ -991 +1059 @@
  * @param   uSourceHeight      Height of the source image (framebuffer).
  * @param   pu8BufAddr         Pointer to source image(framebuffer).
- * @param   u64TimeStamp       Time stamp (milliseconds).
+ * @param   u64TimeStampMs     Time stamp (in ms).
  */
 int VideoRecCopyToIntBuf(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint32_t x, uint32_t y,
                          uint32_t uPixelFormat, uint32_t uBitsPerPixel, uint32_t uBytesPerLine,
                          uint32_t uSourceWidth, uint32_t uSourceHeight, uint8_t *pu8BufAddr,
-                         uint64_t u64TimeStamp)
+                         uint64_t uTimeStampMs)
 {
     /* Do not execute during termination and guard against termination */
@@ -1005 +1073 @@
     do
     {
-        AssertPtrBreakStmt(pu8BufAddr,                     rc = VERR_INVALID_PARAMETER);
-        AssertBreakStmt(uSourceWidth,                      rc = VERR_INVALID_PARAMETER);
-        AssertBreakStmt(uSourceHeight,                     rc = VERR_INVALID_PARAMETER);
-        AssertBreakStmt(uScreen < pCtx->vecStreams.size(), rc = VERR_INVALID_PARAMETER);
-
-        PVIDEORECSTREAM pStream = pCtx->vecStreams.at(uScreen);
+        AssertPtrBreakStmt(pCtx,       rc = VERR_INVALID_POINTER);
+        AssertPtrBreakStmt(pu8BufAddr, rc = VERR_INVALID_POINTER);
+        AssertBreakStmt(uSourceWidth,  rc = VERR_INVALID_PARAMETER);
+        AssertBreakStmt(uSourceHeight, rc = VERR_INVALID_PARAMETER);
+
+        PVIDEORECSTREAM pStream = videoRecStreamGet(pCtx, uScreen);
+        if (!pStream)
+        {
+            rc = VERR_NOT_FOUND;
+            break;
+        }
+
         if (!pStream->fEnabled)
         {
@@ -1016 +1090 @@
             break;
         }
-        if (u64TimeStamp < pStream->u64LastTimeStamp + pStream->uDelay)
+        if (uTimeStampMs < pStream->uLastTimeStampMs + pStream->uDelay)
         {
             rc = VINF_TRY_AGAIN; /* respect maximum frames per second */
@@ -1027 +1101 @@
         }
 
-        pStream->u64LastTimeStamp = u64TimeStamp;
+        pStream->uLastTimeStampMs = uTimeStampMs;
 
         int xDiff = ((int)pStream->uTargetWidth - (int)uSourceWidth) / 2;
@@ -1127 +1201 @@
         }
 
-        pStream->u64TimeStamp = u64TimeStamp;
+        pStream->uCurTimeStampMs = uTimeStampMs;
 
         ASMAtomicWriteBool(&pStream->fRgbFilled, true);

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

@@ -36 +36 @@
                           uint32_t x, uint32_t y, uint32_t uPixelFormat, uint32_t uBitsPerPixel,
                           uint32_t uBytesPerLine, uint32_t uGuestWidth, uint32_t uGuestHeight,
-                          uint8_t *pu8BufferAddress, uint64_t u64TimeStamp);
-bool VideoRecIsReady(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStamp);
-bool VideoRecIsFull(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStamp);
+                          uint8_t *pu8BufferAddress, uint64_t u64TimeStampMs);
+bool VideoRecIsReady(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStampMs);
+bool VideoRecLimitReached(PVIDEORECCONTEXT pCtx, uint32_t uScreen, uint64_t u64TimeStampMs);
 
 #endif /* !____H_VIDEOREC */